package com.xyh.cloudorder.utils;

import org.springframework.util.StringUtils;

import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;


/*import com.apt.util.ChkUtil;
import com.apt.util.NumberFormat;
import com.apt.util.arith.ArithUtil;
import com.apt.util.date.DateUtil;*/

/**
 * 
 * 功能说明：日期时间类
 * @author kuiye
 * 修改人: 
 * 修改原因：
 * 修改时间：
 * 修改内容：
 * 创建日期：2018-10-10
 * Copyright xyh-apt
 */
public class DateUtil {
	
	
	public final static String STYLE_1 = "yyyy-MM-dd HH:mm:ss";
	
	public final static String STYLE_2 = "yyyy-MM-dd";
	
	public final static String STYLE_3 = "yyyyMMdd";
	
	public final static String STYLE_4 = "yyyyMMddhh";
	
	public final static String STYLE_5 = "yyyyMMddhhmm";
	
	public final static String STYLE_6 = "yyyy年MM月dd日HH时mm分ss秒";
	
	public final static String STYLE_7 = "yyyy年MM月dd日HH时mm分";
	
	public final static String STYLE_8 = "yyyy年MM月dd日";
	
	public final static String STYLE_9 = "hhmmss";
	
	public final static String STYLE_10 = "yyyyMMddhhmmss";
	
	//client版本是没有 下面5个 并且 clent的11 和 10是一样的的 将clent的10改成现在的11
	public final static String STYLE_11 = "HH:mm:ss";
	
	public final static String STYLE_12 = "yyyy";  
	
	public final static String STYLE_13 = "yyyy-MM";
	
	public final static String STYLE_14 = "dd";
	
	public final static String STYLE_15 = "ddMMyyyyhhmmssSSS";
	
	/**
	 * 
	 * 功能说明：获得当前时间			
	 * kuiye  2014-11-29
	 * @param style 时间类型		如果style 则默认返回yyyy-MM-dd HH:mm:ss
	 * @return String 时间字符串   
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getCurrentTime(String style) {
		if(StringUtils.isEmpty(style)){
			style = STYLE_1;
		}
		
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		String str = sdf.format(new Date());
		return str;
	}
	
	/**
	 * 
	 * 功能说明：获得当前时间			
	 * kuiye  2014-11-29
	 * @param style 时间类型		如果style 则默认返回yyyy-MM-dd HH:mm:ss
	 * @return String 时间字符串   
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getCurrentTime() {
		SimpleDateFormat sdf = new SimpleDateFormat(STYLE_1);
		String str = sdf.format(new Date());
		return str;
	}
	
	/**
	 * 
	 * 功能说明：获得指定时间的样式			
	 * kuiye  2014-11-29
	 * @param times 		指定时间
	 * @return String 时间样式
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getDateStyle(String times) {
		
		try {
			formatDate(times,STYLE_1);
			return STYLE_1;
		} catch (Exception e) {
//			e.printStackTrace();
		}
		
		try {
			formatDate(times,STYLE_2);
			return STYLE_2;
			
		} catch (Exception e) {
//			e.printStackTrace();
		}
		try {
			formatDate(times,STYLE_3);
			return STYLE_3;
			
		} catch (Exception e) {
//			e.printStackTrace();
		}
		
		try {
			formatDate(times,STYLE_4);
			return STYLE_4;
			
		} catch (Exception e) {
//			e.printStackTrace();
		}
		
		try {
			formatDate(times,STYLE_11);
			return STYLE_11;
			
		} catch (Exception e) {
//			e.printStackTrace();
		}
		
		return null;
	}
	
	
	
	/**
	 * 
	 * 功能说明：格式化日期			
	 * kuiye  2014-11-29
	 * @param time 被格式化的日期   fmtStyle  格式化前的样式  wantStyle 格式化后的样式
	 * @return String 格式化后的日期
	 * @throws  ParseException 
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String formatDate(String time,String fmtStyle,String wantStyle) throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat(fmtStyle);
		Date date = sdf.parse(time);
		sdf = new SimpleDateFormat(wantStyle);
		
		return sdf.format(date);
	}
	
	/**
	 * 
	 * 功能说明：格式化日期  	
	 * kuiye  2014-11-29
	 * @param  times 预格式化的日期字符串   style 格式化后的样式  默认是 yyyy-MM-dd HH:mm:ss
	 * @return Date   
	 * @throws  ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static Date formatDate(String times, String style) throws ParseException{
		if (style == null || "".equals(style)) {
			style = STYLE_1;
		}
		if (StringUtils.isEmpty(times)) {
			times = getCurrentTime();
		}
		SimpleDateFormat sdf = new SimpleDateFormat(style);
//		try {
//			return sdf.parse(times);
//		} catch (ParseException e) {
//			e.printStackTrace();
//		}
		return sdf.parse(times);
	}
	public static String formatDate(Date times, String style){
		if (style == null || "".equals(style)) {
			style = STYLE_1;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(style);
//		try {
//			return sdf.parse(times);
//		} catch (ParseException e) {
//			e.printStackTrace();
//		}
		return sdf.format(times);
	}
	
	
	/**
	 * 
	 * 功能说明：格式化日期  	
	 * kuiye  2014-11-29
	 * @param  times 预格式化的日期字符串   style 格式化后的样式  默认是 yyyy-MM-dd HH:mm:ss
	 * @return Date   
	 * @throws  ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static Date formatStyleDate(String times, String style){
		if (style == null || "".equals(style)) {
			style = STYLE_1;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		try {
			return sdf.parse(times);
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}
	
	
	/**
	 * 
	 * 功能说明：根据生日求年龄 周岁			
	 * kuiye  2014-11-29
	 * @param birthDay  生日
	 * @return int 周岁  
	 * @throws  ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int getAgeByBirthDay(String birthDay) throws ParseException {
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat sdf = new SimpleDateFormat(STYLE_2);
		Date date = sdf.parse(birthDay);
		if (cal.before(date)) {
			return 0;
		}

		int yearNow = cal.get(Calendar.YEAR);
		int monthNow = cal.get(Calendar.MONTH);
		int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH);
		cal.setTime(date);

		int yearBirth = cal.get(Calendar.YEAR);
		int monthBirth = cal.get(Calendar.MONTH);
		int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH);

		int age = yearNow - yearBirth;

		if (monthNow <= monthBirth) {
			if (monthNow == monthBirth) {
				if (dayOfMonthNow < dayOfMonthBirth) {
					age--;
				}
			} else {
				age--;
			}
		} else {
			return age;
		}

		return age;
	}
	
	
	/**
	 * 
	 * 功能说明：比较两个日期 大小			
	 * kuiye  2014-11-29
	 * @param DATE1 日期1  DATE2 日期2
	 * @return   返回 int (-1 ：日期1 大于 日期2,0 ：日期1 小于日期2, 1： 日期1 等于日期2) 
	 * @throws 
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int compareDate(String DATE1, String DATE2,String style) {
		int i = 0;
		if(style == null)
			style = STYLE_1;
		
		SimpleDateFormat df = new SimpleDateFormat(style);
		try {
			Date dt1 = df.parse(DATE1);
			Date dt2 = df.parse(DATE2);
			if (dt1.getTime() > dt2.getTime()) {
				i = -1;
			} else if (dt1.getTime() < dt2.getTime()) {
				i = 0;
			} else if (dt1.getTime() == dt2.getTime()) {
				i = 1;
			}

		} catch (Exception exception) {
			exception.printStackTrace();
			i = 0;
		}
		return i;
	}
	
	
	/**
	 * 
	 * 功能说明：比较两个日期 大小			
	 * kuiye  2014-11-29
	 * @param DATE1 日期1  DATE2 日期2
	 * @return   返回 int (-1 ：日期1 大于 日期2,0 ：日期1 小于日期2, 1： 日期1 等于日期2) 
	 * @throws 
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int compareDate(String DATE1, String DATE2) {
		int i = 0;
		SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		try {
			Date dt1 = df.parse(DATE1);
			Date dt2 = df.parse(DATE2);
			if (dt1.getTime() > dt2.getTime()) {
				i = -1;
			} else if (dt1.getTime() < dt2.getTime()) {
				i = 0;
			} else if (dt1.getTime() == dt2.getTime()) {
				i = 1;
			}

		} catch (Exception exception) {
			exception.printStackTrace();
		}
		return i;
	}
	
	
	/**
	 * 
	 * 功能说明：获得指定日期的最后一天			
	 * kuiye  2014-11-29
	 * @param  date 指定日期
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static Date lastDayOfMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.set(Calendar.DAY_OF_MONTH, 1);
		cal.roll(Calendar.DAY_OF_MONTH, -1);
		return cal.getTime();
	}
	/**
	 * 
	 * 功能说明：获得指定日期的第一天			
	 * kuiye  2014-11-29
	 * @param  date 指定日期
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static Date firstDayOfMonth(Date date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(date);
		cal.set(Calendar.DAY_OF_MONTH, 1);
//		cal.roll(Calendar.DAY_OF_MONTH, 1);
		return cal.getTime();
	}
	public static void main(String[] args) {
		try {
			
			String totalDate = DateUtil.getBeforeTime("2017-01-01", 1, 1, DateUtil.STYLE_2);
			totalDate = DateUtil.formatDate(DateUtil.formatStyleDate("2016-01", DateUtil.STYLE_13),DateUtil.STYLE_13);
			System.out.println("totalDate:"+totalDate);
			System.out.println(DateUtil.getCurrentTime(DateUtil.STYLE_13));
			String lastDay =DateUtil.formatDate(DateUtil.lastDayOfMonth(DateUtil.formatStyleDate("2016-2", DateUtil.STYLE_13)),DateUtil.STYLE_2);
			System.out.println(lastDay);
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 
	 * 功能说明：获得本月第一天日期	 	
	 * kuiye  2014-11-29
	 * @param 
	 * @return   String 2015-05-01
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getMonthBegin() {
		Calendar localTime = Calendar.getInstance();
		String strY = null;
		int x = localTime.get(Calendar.YEAR);
		int y = localTime.get(Calendar.MONTH) + 1;
		strY = y >= 10 ? String.valueOf(y) : ("0" + y);
		return x + "-" + strY + "-01";
	}
	
	/**
	 * 
	 * 功能说明：获得本月最后一天日期	 	
	 * kuiye  2014-11-29
	 * @param 
	 * @return   String 2015-05-01
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getMonthEnd() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.YEAR, calendar.get(Calendar.YEAR));
		calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH));
		int endday = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
		return calendar.get(Calendar.YEAR) + "-"+ (calendar.get(Calendar.MONTH) + 1) + "-" + endday;
	}
	
	
	/**
	 * 
	 * 功能说明：判断指定日期是否为周六			
	 * kuiye  2014-11-29
	 * @param  date  日期字符串
	 * @return   
	 * @throws  ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static boolean isWeekOfSaturday(String date) throws ParseException {

		DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
		Date bdate = format1.parse(date);
		Calendar cal = Calendar.getInstance();
		cal.setTime(bdate);
		if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY)
			return true;
		return false;
	}
	
	
	/**
	 * 
	 * 功能说明：判断指定日期是否为周日			
	 * kuiye  2014-11-29
	 * @param  date  日期字符串
	 * @return   
	 * @throws  ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static boolean isWeekOfSunday(String bDate) throws ParseException {

		DateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
		Date bdate = format1.parse(bDate);
		Calendar cal = Calendar.getInstance();
		cal.setTime(bdate);
		if (cal.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY)
			return true;
		return false;
	}
	
	
	/**
	 * 
	 * 功能说明：求得指定日期的前N天日期			
	 * kuiye  2014-11-29
	 * @param  date 日期 ，day 天数 ，style 预转换的日期格式 （默认为 yyyy-MM-dd HH:mm:ss）
	 * @return  String  
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getBefore(Date date, int day,String style) {
		if(StringUtils.isEmpty(style)){
			style = STYLE_1;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		now.set(Calendar.DATE, now.get(Calendar.DATE) - day);
		sdf.format(date);
		return  sdf.format(now.getTime());
	}
	
	
	/**
	 * 
	 * 功能说明：是否为闰年			
	 * kuiye  2015-5-13
	 * @param year 年份	
	 * @return   boolean 
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static boolean leapYear(int year) {
		boolean leap;
		if (year % 4 == 0) {
			if (year % 100 == 0) {
				if (year % 400 == 0)
					leap = true;
				else
					leap = false;
			} else
				leap = true;
		} else
			leap = false;
		return leap;
	}
	
	
	/**
	 * 
	 * 功能说明：根据当前日期计算出后面几个月后的日期或者 几天后的日期			
	 * kuiye  2015-5-13
	 * @param nowTime 当时日期     type{2 代表月 其它代表 日}   style 指定格式化日期样式 默认 yyyy-MM-dd HH:mm:ss	
	 * @return   
	 * @throws	 ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getLastTime(String nowTime, int type, int increment,String style) throws ParseException {
		if (style == null || "".equals(style)) {
			style = STYLE_1;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(sdf.parse(nowTime));
		if (type == 2)
			calendar.add(Calendar.MONTH, increment);
		else if(type == 1)
			calendar.add(Calendar.DAY_OF_MONTH, increment);
		else
			calendar.add(Calendar.HOUR_OF_DAY, increment);
		String sdate = sdf.format(calendar.getTime());
		calendar.setTime(sdf.parse(sdate));
		return sdate;
	}
	
	
	/**
	 * 
	 * 功能说明：根据当前日期计算出后面几个月前的日期或者 几天后的日期			
	 * kuiye  2015-5-13
	 * @param nowTime 当时日期     type{2 代表月 其它代表 日}   style 指定格式化日期样式 默认 yyyy-MM-dd HH:mm:ss	
	 * @return   
	 * @throws	 ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getBeforeTime(String nowTime, int type, int increment,String style) throws ParseException {
		if (style == null || "".equals(style)) {
			style = STYLE_1;
		}
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(sdf.parse(nowTime));
		if (type == 2)
			calendar.add(Calendar.MONTH, -increment);
		else if(type == 1)
			calendar.add(Calendar.DAY_OF_MONTH, -increment);
		else
			calendar.add(Calendar.HOUR_OF_DAY, -increment);
		String sdate = sdf.format(calendar.getTime());
		calendar.setTime(sdf.parse(sdate));
		return sdate;
	}
	
	
	/**
	 * 根据传递的时间类型，获取当前日期的前一天
	 * @param style
	 * @return
	 * @throws ParseException
	 */
	public static String getBeforeDay(String style) throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		String sdate = sdf.format(calendar.getTime());
		calendar.setTime(sdf.parse(sdate));
		return sdate;
	}
	
	/**
	 * 根据传递的时间类型，获取指定天数以后的日期
	 * @param style
	 * @return
	 * @throws ParseException
	 */
	public static String getAfterDay(String datestr,String style,int n) throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(sdf.parse(datestr));
		calendar.add(Calendar.DAY_OF_MONTH, n);
		String sdate = sdf.format(calendar.getTime());
		return sdate;
	}
	/**
	 * 
	 * 功能说明：根据当前日期计算出后面几个月后的日期或者 几天后的日期			
	 * kuiye  2015-5-13
	 * @param nowTime 当时日期     type{2 代表月 其它代表 日}   style 指定格式化日期样式 默认 yyyy-MM-dd HH:mm:ss	
	 * @return   
	 * @throws	 ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getBocLastTime(String nowTime, int type, int increment,String style){
		String sdate ="";
		try{
			if (style == null || "".equals(style)) {
				style = STYLE_1;
			}
			SimpleDateFormat sdf = new SimpleDateFormat(style);
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(sdf.parse(nowTime));
			if (type == 2)
				calendar.add(Calendar.MONTH, increment);
			else
				calendar.add(Calendar.DAY_OF_MONTH, increment);
	
			sdate = sdf.format(calendar.getTime());
			calendar.setTime(sdf.parse(sdate));
		}catch (Exception e) {
			e.printStackTrace();
		}
		return sdate;
	}
	
	
	/**
	 * 
	 * 功能说明：求两个日期之间相隔天数	
	 * kuiye  2015-5-13
	 * @param  time1 日期1   time2 日期2
	 * @return long   相差天数
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static long getBetweenDaysNew(String time1, String time2) {
		long quot = 0;
		SimpleDateFormat ft = new SimpleDateFormat(STYLE_2);
		try {
			Date date1 = ft.parse(time1);
			Date date2 = ft.parse(time2);
			quot = date1.getTime() - date2.getTime();
			quot = quot / 1000 / 60 / 60 / 24;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return quot;
	}
	
	
	/**
	 * 
	 * 功能说明：求两个日期之间相隔天数	
	 * kuiye  2015-5-13
	 * @param  time1 日期1   time2 日期2
	 * @return long   相差天数
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static long getBetweenDays(String time1, String time2) {
		long quot = 0;
		SimpleDateFormat ft = new SimpleDateFormat(STYLE_2);
		try {
			Date date1 = ft.parse(time1);
			Date date2 = ft.parse(time2);
			quot = date1.getTime() - date2.getTime();
			quot = quot / 1000 / 60 / 60 / 24;
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return Math.abs(quot);
	}
	
	
	/**
	 * 
	 * 功能说明：求两个日期相差的天数			
	 * kuiye  2015-5-13
	 * @param 
	 * @return   天数（int）
	 * @throws  ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int diffDays(String startDate, String endDate)throws ParseException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Calendar cal = Calendar.getInstance();
		cal.setTime(sdf.parse(startDate));
		long startTime = cal.getTimeInMillis();
		cal.setTime(sdf.parse(endDate));
		long endTime = cal.getTimeInMillis();
		long between_days = (endTime - startTime) / (1000 * 3600 * 24);

		return Integer.parseInt(String.valueOf(between_days));
	}
	
	
	/**
	 * 
	 * 功能说明：求两个日期相差的秒/分/时		
	 * kuiye  2015-5-13
	 * @param date1 日期1  date2 日期2  type（1 秒 2 分 3 时）
	 * @return   
	 * @throws  ParseException
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static long getBetweenTimes(String date1,String date2,int type)throws ParseException{
		SimpleDateFormat s = new SimpleDateFormat(STYLE_1);
		long t1 = s.parse(date1).getTime();
		long t2 = s.parse(date2).getTime();
		long result = 0;
		switch (type) {
		//秒
		case 1:
			result = (t2 - t1)/1000;
			break;
			
		//分	
		case 2:	
			result = (t2 - t1)/1000/60;
			break;
		
		//时
		case 3:
			result = (t2 - t1)/1000/60/60;
			break;
		default:
			break;
		}
		return result;
	}
	
	
	/**
	 * 
	 * 功能说明：比较两个日期  			
	 * kuiye  2015-5-13
	 * @param x天x小时x分
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 * @throws ParseException 
	 */
	public static String getDistanceTime(String str1, String str2) throws ParseException {
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date one;
		Date two;
		long day = 0;
		long hour = 0;
		long min = 0;
		one = df.parse(str1);
		two = df.parse(str2);
		long time1 = one.getTime();
		long time2 = two.getTime();
		if (time2 <= time1)
			return 0 + "天" + 0 + "小时" + 0 + "分";

		long diff = time2 - time1;
		day = diff / (24 * 60 * 60 * 1000);
		hour = (diff / (60 * 60 * 1000) - day * 24);
		min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
		return day + "天" + hour + "小时" + min + "分";
	}
	
	
	/**
	 * 
	 * 功能说明：得到当前时间所处的时间段			
	 * kuiye  2015-5-13
	 * @param 
	 * @return   1  凌晨 2 早上 3中午 4下午 5 晚上
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int PeriodOfTime(){
		Calendar calendar =  Calendar.getInstance(); 
		int hours = calendar.get(Calendar.HOUR_OF_DAY);
		int result = 0;
		//早上
		if(hours >=0 && hours <= 5){
			//凌晨
			result = 1;
		}else if(hours >=6 && hours <= 10){
			//早上
			result = 2;
		}else if(hours >=11 && hours <= 13){
			//中午
			result = 3;
		}else if(hours >=14 && hours <= 18){
			//下午
			result = 4;
		}else if(hours >=19 && hours <= 24){
			//晚上
			result = 5;
		}
		return result;
	}
	
	
	/**
	 * 
	 * 功能说明：获得当前年份			
	 * kuiye  2015-5-13
	 * @param 
	 * @return   年份
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int getCurrentYear(){
		Calendar cal = Calendar.getInstance();
		return cal.get(Calendar.YEAR);
	}
	
	
	/**
	 * 
	 * 功能说明：获得当前月份			
	 * kuiye  2015-5-13
	 * @param 
	 * @return  月份
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int getCurrentMonth(){
		Calendar cal = Calendar.getInstance();
		return cal.get(Calendar.MONTH) + 1;
	}
	
	
	/**
	 * 
	 * 功能说明：获得当前日份			
	 * kuiye  2015-5-13
	 * @param 
	 * @return  日
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int getCurrentDay(){
		Calendar cal = Calendar.getInstance();
		return cal.get(Calendar.DATE);
	}
	
	
	/**
	 * 
	 * 功能说明：该方法实现的功能			
	 * kuiye  2015-5-13
	 * @param 
	 * @return  日
	 * @throws  
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int getCurrentHour(){
		Calendar cal = Calendar.getInstance();
		return cal.get(Calendar.HOUR_OF_DAY);
	}
	
	
	/**
	 * 根据 年月日 获取 月份
	 * @param time
	 * @return
	 * @throws ParseException
	 */
	public static int getMonthByTime(String time) throws ParseException
	{
		SimpleDateFormat sdf = new SimpleDateFormat(STYLE_2);
		Calendar cal = Calendar.getInstance();
		cal.setTime(sdf.parse(time));
		int month = cal.get(Calendar.MONTH) + 1;
		return month;
	}
	
	
	/**
	 * 根据 年月日 获取 月份
	 * @param time
	 * @return
	 * @throws ParseException
	 */
	public static int getYearByTime(String time) throws ParseException
	{
		SimpleDateFormat sdf = new SimpleDateFormat(STYLE_2);
		Calendar cal = Calendar.getInstance();
		cal.setTime(sdf.parse(time));
		int year = cal.get(Calendar.YEAR);
		return year;
	}
	
	
	/**
	 * 根据 年月日 获取 月份
	 * @param time
	 * @return
	 * @throws ParseException
	 */
	public static int getDayByTime(String time) throws ParseException
	{
		SimpleDateFormat sdf = new SimpleDateFormat(STYLE_2);
		Calendar cal = Calendar.getInstance();
		cal.setTime(sdf.parse(time));
		int day = cal.get(Calendar.DAY_OF_MONTH);
		return day;
	}
	
	
	/**
	 * 根据 年 月 获取 本月 最后一天
	 * @param year
	 * @param month
	 * @return
	 */
	public static String getMonthEndByTime(int year, int month) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.YEAR, year);
		calendar.set(Calendar.MONTH, month - 1);
		int endday = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
		int monthmon = calendar.get(Calendar.MONTH) + 1;
		String mon = monthmon < 10 ? "0" + monthmon : monthmon + "";
		return calendar.get(Calendar.YEAR) + "-"+ mon + "-" + endday;
	}

	
	/**
	 * 根据 年 月 判断 day 是否最后一天
	 * @param year
	 * @param month
	 * @param day
	 * @return
	 */
	public static boolean judgeMonthEndDay(int year, int month, int day) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.YEAR, year);
		calendar.set(Calendar.MONTH, month - 1);
		int endday = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
		if (endday == day) 
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 根据 年 月 判断 day 是否最后一天
	 * @param year
	 * @param month
	 * @param day
	 * @return
	 */
	public static boolean judgeMonthBeginDay(int year, int month, int day) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.YEAR, year);
		calendar.set(Calendar.MONTH, month - 1);
		int endday = calendar.getActualMinimum(Calendar.DAY_OF_MONTH);
		if (endday == day) 
		{
			return true;
		}
		return false;
	}
	
	
	/**
	 * 
	 * 功能说明：格式化日期			
	 * kuiye  2014-11-29
	 * @param time 被格式化的日期   fmtStyle  格式化前的样式  wantStyle 格式化后的样式
	 * @return String 格式化后的日期
	 * @throws  ParseException 
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String toFormatDate(String time,String fmtStyle,String wantStyle) throws ParseException{
		SimpleDateFormat sdf = new SimpleDateFormat(fmtStyle);
		Date date = sdf.parse(time);
		sdf = new SimpleDateFormat(wantStyle);
		
		return sdf.format(date);
	}
	
	
	/**
	 * 
	 * 功能说明：获得 当前时间的前几分钟时间		
	 * kuiye  2015-6-1
	 * @param 
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getBeforeSeconds(int second,String style){
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat(style);
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		now.set(Calendar.SECOND, now.get(Calendar.SECOND) - second);
		sdf.format(date);
		return sdf.format(now.getTime());
	}
	
	
	/**
	 * 计算两个日期相差的天数
	 * @param str1 较小的日期
	 * @param str2 较大的日期
	 * @return str2-str1
	 * @throws ParseException
	 */
	public static int getDateByNumberOfDays(String str1,String str2) throws ParseException{
		DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date one;
		Date two;
		long day = 0;
		//long hour = 0;
		//long min = 0;
		one = df.parse(str1);
		two = df.parse(str2);
		long time1 = one.getTime();
		long time2 = two.getTime();
		if (time2 <= time1)
			return 0;

		long diff = time2 - time1;
		day = diff / (24 * 60 * 60 * 1000);
		//hour = (diff / (60 * 60 * 1000) - day * 24);
		//min = ((diff / (60 * 1000)) - day * 24 * 60 - hour * 60);
		return (int) day;
	}
	
	
	/**
	 * 
	 * 功能说明：获得某个日期N个月份之前的的月份	
	 * 关福旺  2015-11-19 15:19:09
	 * @param 
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：关福旺
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String  getBefore(String dateStr,String style, int n) throws ParseException {
	       Calendar datebefore = Calendar.getInstance();//获得一个日历的实例
	       SimpleDateFormat sdf = new SimpleDateFormat(style);
	       Date date = null;
	       try{
	         date = sdf.parse(dateStr);//初始日期
	       }catch(Exception e){

	       }
	       datebefore.setTime(date);//设置日历时间
	       if(style.equals(DateUtil.STYLE_12)){
	    	   datebefore.add(Calendar.YEAR,-n);//在日历的月份上减少呢n个年
	       }
	       if(style.equals(DateUtil.STYLE_13)){
	    	   datebefore.add(Calendar.MONTH,-n);//在日历的月份上减少呢n个月
	       }
	       
	       String result = sdf.format(datebefore.getTime());
	    return result;
	}
	/**
	 * 
	 * 功能说明：获得某个日期N个月份之后的月份（包含该日期所在的月份，不能超过当前月份）
	 * 关福旺  2015-11-19 15:19:09
	 * @param 
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：关福旺
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getAfter(String dateStr,String style, int n) throws ParseException {
       Calendar datebefore = Calendar.getInstance();//获得一个日历的实例
       
       Calendar datacurrent = Calendar.getInstance();//用于获取当前时间
       
       SimpleDateFormat sdf = new SimpleDateFormat(style);
       
       Date date = null;
       try{
         date = sdf.parse(dateStr);//初始日期
       }catch(Exception e){

       }
       datebefore.setTime(date);//设置日历时间
       if(style.equals(DateUtil.STYLE_12)){
    	   datebefore.add(Calendar.YEAR,n);//在日历的月份上添加n个年
       }
       if(style.equals(DateUtil.STYLE_13)){
    	   datebefore.add(Calendar.MONTH,n);//在日历的月份上添加n个月
       }
       datacurrent.setTime(new Date());
       
       String result = null;
       
       if(datebefore.getTime().before(datacurrent.getTime())){
    	   result = sdf.format(datebefore.getTime());
       }else{
    	   result = sdf.format(datacurrent.getTime());
       }

       return result;
	}
	
	
	/**
	 * 
	 * 功能说明：获得两个时间之间的差数
	 * wangcy
	 * @param 
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：wangcy
	 * 修改内容：
	 * 修改注意点：
	 */
	public static long getSeconds(String date1,String date2)throws ParseException{
		SimpleDateFormat s = new SimpleDateFormat(STYLE_1);
		long t1 = s.parse(date1).getTime();
		long t2 = s.parse(date2).getTime();
		return t2 - t1;
	}
	
	
	/**
	 * 
	 * 功能说明：获得两个日期之间的所有月份或年份	
	 * 关福旺  2015-11-19 15:19:09
	 * @param 
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：关福旺
	 * 修改内容：
	 * 修改注意点：
	 */
	public static List<String> getDateBetween(String minDate, String maxDate, String style) throws ParseException {
	    ArrayList<String> result = new ArrayList<String>();
	    SimpleDateFormat sdf = new SimpleDateFormat(style);//格式化为年月

	    Calendar min = Calendar.getInstance();
	    Calendar max = Calendar.getInstance();

	    min.setTime(sdf.parse(minDate));
	    min.set(min.get(Calendar.YEAR), min.get(Calendar.MONTH), 1);

	    max.setTime(sdf.parse(maxDate));
	    max.set(max.get(Calendar.YEAR), max.get(Calendar.MONTH), 2);

	    Calendar curr = min;
	    while (curr.before(max)) {
	     result.add(sdf.format(curr.getTime()));
	     if(DateUtil.STYLE_12.equals(style)){
	    	 curr.add(Calendar.YEAR, 1);
	     }
	     if(DateUtil.STYLE_13.equals(style)){
	    	 curr.add(Calendar.MONTH, 1);
	     }
	    }

	    return result;
	}
	
	
	/**
	 * 
	 * 功能说明：根据年月得到一个月有多少天			
	 * yanna  2016-3-2
	 * @param style："yyyy-MM"
	 * @return    
	 * @throws  
	 * 最后修改时间：
	 * 修改人：
	 * 修改内容：
	 * 修改注意点：
	 */
	public static int getDay(String style){
		String[] date = style.split("-");
		int year = Integer.parseInt(date[0]);//得到年份
		int month = Integer.parseInt(date[1]);//得到月份
		Calendar cl=Calendar.getInstance();//实例化一个日历对象
		cl.set(Calendar.YEAR,year);//年设置为2015年
		cl.set(Calendar.MONTH,month-1);//7月的id是6 
		
		//得到一个月最大的一天就是一个月多少天
		return cl.getActualMaximum(Calendar.DATE);
	}
	
	
	/**
	 * 
	 * 功能说明：获得唯一流水号		
	 * kuiye  2015-6-1
	 * @param 
	 * @return   
	 * @throws  该方法可能抛出的异常，异常的类型、含义。
	 * 最后修改时间：
	 * 修改人：kuiye
	 * 修改内容：
	 * 修改注意点：
	 */
	public static String getSerialNo(String preString){
		Date date = new Date();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
		String serialNo =  sdf.format(date);
		String nextString =String.valueOf((int)Math.floor(Math.random()*10000));
		serialNo = serialNo+nextString;
		if(preString!=null){
			serialNo =preString+serialNo;
		}
//		return "000000";//测试数据
		return serialNo;//生产数据
	}
	
	/**
	 * 
	 * 功能说明：重置时间点
	 * kuiye  2015-6-10
	 * @param Map 参数集合
	 * @return   
	 * @throws  
	 * 最后修改时间：
	 * 修改人：yuanhao
	 * 修改内容：
	 * 修改注意点：
	 */
	public  static   List<String> getEveryMonthDay(int size,int day){
		List<String> returnList = new ArrayList<String>(); //结果集
		DecimalFormat  df=new DecimalFormat("00"); 	//格式化集合
		// 当前时间是否和 今天相等
		int currentDay = getCurrentDay();
		
		String currentDate = getCurrentTime(DateUtil.STYLE_2).substring(0,8);
		String milTime= getCurrentTime().substring(11);
		int increamentMonth =0;
		if(currentDay>=day){ //当天小于固定日,则固定日就是固定日
			increamentMonth=1;
		}
		
		for(int i=0;i<size;i++){
			Calendar ca = Calendar.getInstance();
			ca.add(Calendar.MONTH,increamentMonth++);
			int currentMaxDay = ca.getActualMaximum(Calendar.DATE); //本月最大天数
			int finalDay =day;
			if(finalDay>currentMaxDay){
				finalDay = currentMaxDay;
			}
			returnList.add(ca.get(ca.YEAR)+"-"+df.format((ca.get(ca.MONTH)+1))+"-"+df.format(finalDay)+" "+milTime);
		}
		return returnList;
	}
	/**
	 * 把当前日期转换为对应格式的date类型日期
	 * @param pattern 日期格式字符串
	 * @return
	 */
	public static Date currDateToDate(String pattern) {
		Date date = null;
		try {
			SimpleDateFormat sdf = new SimpleDateFormat(pattern);
			Date curdate = new Date();
			String curdateStr = sdf.format(curdate);
			date = sdf.parse(curdateStr);
		}catch (Exception e) {
			e.printStackTrace();
		}
		return date;
	}
}
